#include "test.h"

void testChaineEntree ()
{	
	int args[2] = {ENTREE_TYPECTE_ENTIER,ENTREE_TYPECTE_ENTIER};
	entree e1,e2,e3,e4;
	e1 = nouvelleEntreeCteInt("toto", 23);
	e2 = nouvelleEntreeCteBool("catapulte", FAUX);
	e3 = nouvelleEntreeCteChar("jose", "hey");
	e4 = nouvelleEntreeFct("fonction", 2, args, ENTREE_TYPECTE_BOOL);
	
	printf("\nCréation chaine vide\n");
	pChaineEntreeNode chaine = NULL;
	afficheChaineEntree(chaine);
	
	printf("\nAjout (toto,23) puis (catapulte,faux) puis (jose,hey) puis (bool fonction(int int))\n");
	chaine = ajoutChaineEntreeNodeDebut(e1, chaine);
	afficheChaineEntree(chaine);
	chaine = ajoutChaineEntreeNodeDebut(e2, chaine);
	afficheChaineEntree(chaine);
	chaine = ajoutChaineEntreeNodeDebut(e3, chaine);
	afficheChaineEntree(chaine);
	chaine = ajoutChaineEntreeNodeDebut(e4, chaine);
	afficheChaineEntree(chaine);
	
	printf("\nVider la chaine\n");
	afficheChaineEntree(chaine);
	while(!chaineEntreeEstNull(chaine))
	{
		chaine = suppressionChaineEntreeDebut(chaine);
		afficheChaineEntree(chaine);
	}	
}

void testPileChaineEntree ()
{	
	int args[2] = {ENTREE_TYPECTE_ENTIER,ENTREE_TYPECTE_ENTIER};
	entree e1,e2,e3,e4;
	e1 = nouvelleEntreeCteInt("toto", 23);
	e2 = nouvelleEntreeCteBool("catapulte", FAUX);
	e3 = nouvelleEntreeCteChar("jose", "hey");
	e4 = nouvelleEntreeFct("fonction", 2, args, ENTREE_TYPECTE_BOOL);
	
	pChaineEntreeNode chaine = NULL;
	pPileChaineEntreeNode blocs = NULL;
	printf("creation chaine : bloc0[(toto,23)  (catapulte,faux)]  bloc1[(jose,hey)]  bloc2[(bool fonction(int int))]\n");
	chaine = ajoutChaineEntreeNodeDebut(e1, chaine);
	blocs = ajoutPileChaineEntreeNodeDebut(chaine,blocs);
	chaine = ajoutChaineEntreeNodeDebut(e2, chaine);
	chaine = ajoutChaineEntreeNodeDebut(e3, chaine);
	blocs = ajoutPileChaineEntreeNodeDebut(chaine,blocs);
	chaine = ajoutChaineEntreeNodeDebut(e4, chaine);
	blocs = ajoutPileChaineEntreeNodeDebut(chaine,blocs);
	
	printf("chaine :\n");
	afficheChaineEntree(chaine);
	
	printf("blocs :\n");
	affichePileChaineEntree(blocs);	
}

void testChaineChaineEntree ()
{
	int args[2] = {ENTREE_TYPECTE_ENTIER,ENTREE_TYPECTE_ENTIER};
	entree e1,e2,e3,e4,e5,e6,e7,e8,e9;
	e1 = nouvelleEntreeCteInt("toto", 23);
	e2 = nouvelleEntreeCteBool("catapulte", FAUX);
	e3 = nouvelleEntreeCteChar("jose", "hey");
	e4 = nouvelleEntreeFct("fonction", 2, args, ENTREE_TYPECTE_BOOL);
	e5 = nouvelleEntreeCteInt("suite01", 42);
	e6 = nouvelleEntreeCteBool("suite10", VRAI);
	e7 = nouvelleEntreeCteChar("suite11", "yeaha !");
	e8 = nouvelleEntreeCteInt("tre", 1);
	e9 = nouvelleEntreeCteInt("tro", 2);
	
	pChaineEntreeNode chaine1 = NULL, chaine2 = NULL, chaine3 = NULL;
	printf("creation souschaine1 : (toto,23) (catapulte,faux) (jose,hey) (bool fonction(int int))\n");
	chaine1 = ajoutChaineEntreeNodeDebut(e1, chaine1);
	chaine1 = ajoutChaineEntreeNodeDebut(e2, chaine1);
	chaine1 = ajoutChaineEntreeNodeDebut(e3, chaine1);
	chaine1 = ajoutChaineEntreeNodeDebut(e4, chaine1);
	afficheChaineEntree(chaine1);
		
	printf("creation souschaine2 : (suite01,42) (suite10,vrai) (suite11,yeaha !)\n");
	chaine2 = ajoutChaineEntreeNodeDebut(e5, chaine2);
	chaine2 = ajoutChaineEntreeNodeDebut(e6, chaine2);
	chaine2 = ajoutChaineEntreeNodeDebut(e7, chaine2);
	afficheChaineEntree(chaine2);
		
	printf("creation souschaine3 : (tre,1) (tro,2)\n");
	chaine3 = ajoutChaineEntreeNodeDebut(e8, chaine3);
	chaine3 = ajoutChaineEntreeNodeDebut(e9, chaine3);	
	afficheChaineEntree(chaine3);
	
	printf("\ncreation chaine 3 elements pointent sur souschaines\n");
	pChaineChaineEntreeNode chaine = NULL;
	chaine = ajoutChaineChaineEntreeNodeDebut("maillon0",chaine1,chaine);
	chaine = ajoutChaineChaineEntreeNodeDebut("maillon1",chaine2,chaine);
	chaine = ajoutChaineChaineEntreeNodeDebut("maillon2",chaine3,chaine);
	afficheChaineChaineEntree(chaine);
	
	printf("\nrechercheCibleChaineChaineEntreeNode (maillon0) puis (troll)\n");
	pChaineEntreeNode temp1 = rechercheCibleChaineChaineEntreeNode("maillon0",chaine);
	printf("\tmaillon0 : existe %d : %s\n", temp1 != NULL, temp1 == NULL ? "" : entreeToString(valeurChaineEntreeNode(temp1)));
	temp1 = rechercheCibleChaineChaineEntreeNode("troll",chaine);
	printf("\ttroll :  existe %d : %s\n", temp1 != NULL, temp1 == NULL ? "" : entreeToString(valeurChaineEntreeNode(temp1)));
	
	printf("\nExiste (maillon1) suppression (maillon1) Existe (maillon1)\n");
	printf("\texiste : %d\n",existeChaineChaineEntreeNode("maillon1",chaine));
	chaine = suppressionChaineChaineEntreeNode("maillon1",chaine);
	printf("\texiste : %d\n",existeChaineChaineEntreeNode("maillon1",chaine));
	afficheChaineChaineEntree(chaine);
	
	printf("\nmodifier cible maillon0 pour ancienne maillon1\n");
	modifierCibleChaineChaineEntreeNode("maillon0",chaine2,chaine);
	afficheChaineChaineEntree(chaine);
	
	printf("\nVider la chaine\n");
	afficheChaineChaineEntree(chaine);
	while(!chaineChaineEntreeNodeEstNull(chaine))
	{
		chaine = suppressionChaineChaineEntreeNode(clefChaineChaineEntreeNode(chaine),chaine);
		afficheChaineChaineEntree(chaine);
	}
}

void testHashTable()
{
	entree e;
	
	printf("bloc0-----------+---bloc00---+---bloc000\n");
	printf("  a 1/42        |     d 4    |     c 7\n");
	printf("  b 2           |     a 5    |     b 8\n");
	printf("  c 3           |            |     catapulte 4\n");
	printf("  catapulte 3   |            |     \n");
	printf("                +---bloc01   +---bloc001  \n");
	printf("                      e 6          a 9\n");	
	printf("                                   trololq 3\n");	
	printf("  d 10\n");
	printf("\n");
	printf("(catapulte et trololq meme fct de hash)\n\n\n");
	
	initHashTable();
	initPiles();
	
	printf("\n\n\ntest : valeur a x\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc0 (a b c catapulte)\n");
	e = nouvelleEntreeCteInt("a", 1);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("b", 2);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("c", 3);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("catapulte", 3);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntest : valeur a 1\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\ntest a 1 -> a 42\n");
	majValeurEntiereConstanteEntreeBlocCourant("a",42);
	
	printf("\n\n\ntest : valeur a 42\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc00 (d a)\n");
	entreeBloc();
	e = nouvelleEntreeCteInt("d", 4);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("a", 5);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntest : valeur a 5\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc000 (c b catapulte)\n");
	entreeBloc();
	e = nouvelleEntreeCteInt("c", 7);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("b", 8);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("catapulte", 4);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntest : valeur a x\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc001 (a trololq)\n");
	sortieBloc();
	entreeBloc();
	e = nouvelleEntreeCteInt("a", 9);
	ajoutEntreeHashTable(e);
	e = nouvelleEntreeCteInt("trololq", 3);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntests : existe dans bloc (catapulte : x) (a : o)\n");
	printf("\texiste : %d\n",entreeDejaDansBloc("catapulte"));
	printf("\texiste : %d\n",entreeDejaDansBloc("a"));
	
	printf("\n\n\ntest : valeur a 9\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc01 (e)\n");
	sortieBloc();
	sortieBloc();
	entreeBloc();
	e = nouvelleEntreeCteInt("e", 6);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntest : valeur a x\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nbloc0 bis (d)\n");
	sortieBloc();
	e = nouvelleEntreeCteInt("d", 10);
	ajoutEntreeHashTable(e);
	printf("hashtable :\n");
	afficheHashTable();
	
	printf("\n\n\ntest : valeur a 42\n");
	if(entreeDejaDansBloc("a"))
	{
		e = consulteHashTable("a");
		printf("\t%s",entreeToString(e));
	}
	else
	{
		printf("\ta n'existe pas dans le bloc courant\n");
	}
	
	printf("\n\n\nfin donc vide\n");
	sortieBloc();
	printf("hashtable :\n");
	afficheHashTable();
}


void testHashTableLight()
{
	entree e;
	
	initHashTable();
	initPiles();
	
	e = nouvelleEntreeCteInt("a", 1);
	printf("\tcreation (a,1)\n");
	ajoutEntreeHashTable(e);
	printf("\tajout (a,1) %p\n",recupLigneHashTable(fctHash("a")));
	
	afficheHashTable();	
}
